home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 January / macformat-020.iso / Shareware City / Developers / apps.to.go / Kibitz / CMQueenMate.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-06  |  4.0 KB  |  171 lines  |  [TEXT/MPS ]
  1. /*
  2. ** Apple Macintosh Developer Technical Support
  3. **
  4. ** File:        cmqueenmate.c
  5. ** Written by:  Eric Soldan
  6. **
  7. ** Copyright © 1990-1992 Apple Computer, Inc.
  8. ** All rights reserved. */
  9.  
  10.  
  11.  
  12. /*****************************************************************************/
  13.  
  14.  
  15.  
  16. #include "Kibitz.h"                /* Get the Kibitz includes/typedefs, etc.    */
  17. #include "KibitzCommon.h"        /* Get the stuff in common with rez.        */
  18. #include "Kibitz.protos"        /* Get the prototypes for Kibitz.            */
  19.  
  20.  
  21.  
  22. /*****************************************************************************/
  23.  
  24.  
  25.  
  26. extern short    gPieceLoc;
  27.  
  28.  
  29.  
  30. /*****************************************************************************/
  31.  
  32.  
  33.  
  34. #pragma segment Chess
  35. short    QueenMate(FileRecHndl game)
  36. {
  37.     short            color, myKingLoc, opKingLoc, pieceLoc;
  38.     short            mkr, mkc, okr, okc, pr, pc, row, col;
  39.     short            dr, dc, absdr, absdc;
  40.     short            from, to, val, minVal, minMove;
  41.     short            rspin;
  42.     Boolean            pieceBetween, hflip;
  43.     MoveListHndl    moves;
  44.     short            num, move;
  45.  
  46.     GenerateLegalMoves(game);
  47.     num   = (*game)->doc.numLegalMoves;
  48.     moves = (*game)->doc.legalMoves;
  49.  
  50.     color = WhosMove(game);
  51.     myKingLoc = (*game)->doc.king[color].kingLoc;
  52.     opKingLoc = (*game)->doc.king[1 - color].kingLoc;
  53.     pieceLoc  = gPieceLoc;
  54.  
  55.     for (rspin = 0; rspin < 4; ++rspin) {        /* Rotate until okr < pr < mkr. */
  56.         GetDeltas(pieceLoc, opKingLoc, &dr, &dc, &absdr, &absdc);
  57.         if (dr > 0) {
  58.             GetDeltas(myKingLoc, pieceLoc, &dr, &dc, &absdr, &absdc);
  59.             if (dr > 0) break;
  60.         }
  61.         RSpinPosition(&myKingLoc);
  62.         RSpinPosition(&opKingLoc);
  63.         RSpinPosition(&pieceLoc);
  64.         for (move = 0; move < num; ++move) {
  65.             RSpinPosition(&(**moves)[move].moveFrom);
  66.             RSpinPosition(&(**moves)[move].moveTo);
  67.         }
  68.     }
  69.  
  70.     pieceBetween = (rspin < 4);
  71.     if (!pieceBetween) {
  72.         for (rspin = 0; rspin < 4; ++rspin) {    /* Rotate until myKing 2+ rows below opKing. */
  73.             GetDeltas(myKingLoc, opKingLoc, &dr, &dc, &absdr, &absdc);
  74.             if (dr > 1) break;
  75.             RSpinPosition(&myKingLoc);
  76.             RSpinPosition(&opKingLoc);
  77.             RSpinPosition(&pieceLoc);
  78.             for (move = 0; move < num; ++move) {
  79.                 RSpinPosition(&(**moves)[move].moveFrom);
  80.                 RSpinPosition(&(**moves)[move].moveTo);
  81.             }
  82.         }
  83.     }
  84.  
  85.     GetRowCol(opKingLoc, &okr, &okc);
  86.     hflip = false;
  87.     if (okc > 3) hflip = true;        /* Position opponent king on left side of board. */
  88.     if (hflip) {
  89.         HFlipPosition(&myKingLoc);
  90.         HFlipPosition(&opKingLoc);
  91.         HFlipPosition(&pieceLoc);
  92.         for (move = 0; move < num; ++move) {
  93.             HFlipPosition(&(**moves)[move].moveFrom);
  94.             HFlipPosition(&(**moves)[move].moveTo);
  95.         }
  96.     }
  97.  
  98.     GetRowCol(myKingLoc, &mkr, &mkc);
  99.     GetRowCol(opKingLoc, &okr, &okc);
  100.     GetRowCol(pieceLoc,  &pr,  &pc);
  101.  
  102.     if (!pieceBetween) {
  103.         if ((pr >= mkr) || (pr < okr)) {
  104.             for (minVal = 16, move = 0; move < num; ++move) {
  105.                 from = (**moves)[move].moveFrom;
  106.                 to   = (**moves)[move].moveTo;
  107.                 if (from == pieceLoc) {            /* If piece move... */
  108.                     GetRowCol(to, &row, &col);
  109.                     val = row - okr;
  110.                     if (val < 1) val = 7;
  111.                     GetDeltas(to, opKingLoc, &dr, &dc, &absdr, &absdc);
  112.                     if (absdc < 3) {
  113.                         if (val == 1) val = 7;
  114.                         if (val == 2) val += (3 - absdc);
  115.                     }
  116.                     if (minVal > val) {
  117.                         minVal = val;
  118.                         minMove = move;
  119.                     }
  120.                 }
  121.             }
  122.             GenerateLegalMoves(game);
  123.             return(minMove);
  124.         }
  125.     }
  126.  
  127.     GetDeltas(pieceLoc, opKingLoc, &dr, &dc, &absdr, &absdc);
  128.     from = pieceLoc;
  129.     to = 0;
  130.     for (;;) {
  131.         if (dc < 0) {
  132.             to = from + (okc - pc) + 1;
  133.             if (absdr == 1) ++to;
  134.             break;
  135.         }
  136.         if (dr > 1) {
  137.             to = from - 10 * (dr - 1);
  138.             if (dc == 1) to += (dr - 1);
  139.             if ((opKingLoc == START_IBNDS) && (to == (START_IBNDS + 12))) to += 10;
  140.             break;
  141.         }
  142.         if (!okr) {
  143.             to = opKingLoc + 12;
  144.             if (!okc) ++to;
  145.             if (from != to) break;
  146.         }
  147.         else if ((to = opKingLoc + 12) != from) break;
  148.  
  149.         from = to = myKingLoc;
  150.         if (!mkc) ++to;
  151.         if (mkc > 1) --to;
  152.         if ((mkr - pr) > 1) to -= 10;
  153.         if (to == from) --to;
  154.  
  155.         break;
  156.     }
  157.  
  158.     for (move = 0; move < num; ++move) {
  159.         if ((from == (**moves)[move].moveFrom) && (to == (**moves)[move].moveTo)) {
  160.             GenerateLegalMoves(game);
  161.             return(move);
  162.         }
  163.     }
  164.  
  165.     GenerateLegalMoves(game);        /* This should never happen. */
  166.     return(0);
  167. }
  168.  
  169.  
  170.  
  171.